﻿#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <tuple> // for std::pair
#include<string>
// 一个简单的结构体
//struct Point {
//    int x;
//    int y;
//};
//
//int main() {
//    
//    //std::pair<int, double> p1(42, 3.14);
//    //// 结构化绑定：将 p1 的 first 绑定到 var1, second 绑定到 var2
//    //auto [var1, var2] ( p1); // var1 是 int 类型 (p1.first 的副本), var2 是 double 类型 (p1.second 的副本)
//    //var1 = 100;             // 修改 var1 不会影响 p1.first
//    //std::cout << "p1.first: " << p1.first << ", var1: " << var1 << std::endl;
//
// 
//    //point pt{ 10, 20 };
//    //// 结构化绑定：将 pt.x 绑定到 a, pt.y 绑定到 b
//    //auto [a, b] = pt; // a 是 int 类型 (pt.x 的副本), b 是 int 类型 (pt.y 的副本)
//    //a = 99;            // 修改 a 不会影响 pt.x
//    //std::cout << "pt.x: " << pt.x << ", a: " << a << std::endl;
//
//    //// 示例 3: 使用 const 对象
//    //const Point cpt{ 100, 200 };
//    //// 结构化绑定：将 cpt.x 绑定到 c, cpt.y 绑定到 d
//    //auto [c, d] = cpt;
//    // c = 50; //可以修改
//    //std::cout << "cpt.x: " << cpt.x << ", c: " << c << std::endl;
//
//    //// 示例 4: 引用绑定
//    //Point pt2{ 30, 40 };
//    //// 使用引用进行结构化绑定：a_ref 是 pt2.x 的引用, b_ref 是 pt2.y 的引用
//    //auto& [a_ref, b_ref] = pt2;
//    //a_ref = 33; // 这会直接修改 pt2.x
//    //b_ref = 44; // 这会直接修改 pt2.y
//    //std::cout << "pt2.x: " << pt2.x << ", a_ref: " << a_ref << std::endl;
//
//
//
//    //delete ppt;
//
//    //// 示例 6: 不支持嵌套绑定 (正如OCR中强调的)
//    // 假设有一个 std::tuple<int, std::pair<int, int>, double>
//    //std::tuple<int, std::pair<int, int>, double> nested_tuple(1, std::make_pair(2, 3), 4.5);
//    // auto [w, [u, v], z] = nested_tuple; // 编译错误: 变量数量须与表达式元素数量匹配
//
//    //// 正确的做法是为嵌套的 pair 单独进行解包，或者使用 std::tie
//    //int w;
//    //std::pair<int, int> uv_pair;
//    //double zz;
//    //std::tie(w, uv_pair, zz) = nested_tuple; // OK
//    //// 或者，如果希望进一步解包 uv_pair:
//    //int u, v;
//    //std::tie(u, v) = uv_pair; // OK
//
//
//
//     std::tuple<int, double, std::string> t(1, 2.3, "hello");
//     auto [a1, b1, c1] = t;
//     auto& [a2, b2, c2] = t;
//     auto&& [a3, b3, c3] = move(t);
//    // auto& [a4, b4] = std::make_tuple(1, 2); // 编译报错
//     auto&& [a5, b5] = std::make_tuple(1, 2);
//    return 0;
//}

//#include"tmp.h"
//
//
//class  A {
//
//
//public:
//
//	static const int a = 1;
//	inline static int b = 2;
//
//	inline static std::string  s = "111";
//
//
//};
//void func();
//int main() {
//	func();//使用外部链接
//	std::cout << &x << std::endl;
//	std::cout << &y << std::endl;
//}


//#include <iostream>
//#include <map>
//#include <string>
//void ifWithInit() {
//	std::map<std::string, int> m = { {"Alice", 25}, {"Bob", 30} };
//	// 在if条件中初始化变量
//	if (auto it = m.find("Alice"); it != m.end()) {
//		std::cout << "Found Alice, age: " << it->second << std::endl;
//	} 
//
//	else if (auto it = m.find("Bob"); it != m.end()) {
//		std::cout << "Found Bob, age: " << it->second << std::endl;
//	}
//
//	else{
//		std::cout << " not found" << std::endl;
//	} 
//
//		// 变量it的作⽤域仅限于if - else块
//}
//
//int checkValue(int v) {
//	return v % 2;
//}
//void switchWithInit(int value) {
//	// 在switch条件中初始化变量
//	switch (auto status = checkValue(value); status) {
//	case 0:
//		std::cout << "Status is zero" << std::endl;
//		break;
//	case 1:
//		std::cout << "Status is one" << std::endl;
//		break;
//	default:
//		std::cout << "Unknown status: " << status << std::endl;
//	} 
//	// status的作⽤域仅限于switch块
//		
//}



/*if constexpr:*/


//#include <iostream>
//#include <type_traits>
//
//template<typename T>
//auto printTypeInfo(const T& value) {
//	if  (std::is_integral_v<T>) {
//		std::cout << value << " is an integral type" << std::endl;
//	}
//	else if  (std::is_floating_point_v<T>) {
//		std::cout << value << " is a floating point type" << std::endl;
//	} 
//	else if  (std::is_pointer_v<T>) {
//		std::cout << "Pointer to " << *value << std::endl;
//	} 
//	else{
//		std::cout << value << " is some other type" << std::endl;
//	}
//}
//
//
//int main() {
//	printTypeInfo(42);
//	/*printTypeInfo(3.14);
//	int x = 10;
//	printTypeInfo(&x);
//	printTypeInfo("hello");*/
//
//
//}

#include<iostream>
//void printArgs() {
//
//}
//template<typename T, typename... Args>
//void printArgs(T&& arg, Args&&... args) {
//	std::cout << arg;
//	if  constexpr (sizeof...(args) > 0) {
//		std::cout << ", ";
//		printArgs(std::forward<Args>(args)...);
//	} 
//	
//	else {
//		std::cout << std::endl;
//	}
//}
//
//
//int main() {
//
//	printArgs(1, 2.5, "three", '4');
//}


/*强制拷贝省略策略*/

//struct Noisy
//{
//	Noisy() { std::cout << "constructed at " << this << '\n'; }
//	Noisy(const Noisy&) { std::cout << "copy-constructed\n"; }
//	Noisy(Noisy&&) { std::cout << "move-constructed\n"; }
//	~Noisy() { std::cout << "destructed at " << this << '\n'; }
//};
//Noisy f()
//{
//	Noisy v = Noisy(); // (until C++17) copy elision initializing v from atemporary;
//	// the move constructor may be called
//	// (since C++17) "guaranteed copy elision"
//	return v; // copy elision ("NRVO") from v to the result object;
//	// the move constructor may be called
//} 
//
//void g(Noisy arg)
//{
//	std::cout << "&arg = " << &arg << '\n';
//}
//int main()
//{
//	Noisy v = f(); // (until C++17) copy elision initializing v from the
//	
//		// (since C++17) "guaranteed copy elision"
//		std::cout << "&v = " << &v << '\n';
//	g(f()); // (until C++17) copy elision initializing arg from the result of
//	f();
//		// (since C++17) "guaranteed copy elision"
//}



//
//struct NonMoveable {
//	NonMoveable() {
//
//		std::cout << "NonMoveable()" << std::endl;
//	}
//	NonMoveable(const NonMoveable&) = delete; // 禁⽌拷⻉
//	NonMoveable(NonMoveable&&) = delete; // 禁⽌移动
//};
//NonMoveable make() {
//
//
//	NonMoveable v = NonMoveable();
//	return v; //  在 C++14 中编译错误！
//	// 因为语⾔逻辑上要求调⽤已删除的移动构造函数
//} 
//int main() {
//	NonMoveable nm = make(); //  同样错误
//}

/*折叠表达式*/


#include<iostream>
// 1、⼀元左折叠
//template<typename... Args>
//bool all(Args... args)
//{
//	return (... && args);
//	// return ((true && true) && true) && false;
//} 
//// 2、⼀元右折叠
//template<typename... Args>
//auto sum(Args... args) {
//	return (args + ...);
//	// 等价于 return (arg1 + (arg2 + (arg3 + ...)));
//} 
//int main()
//{
//	std::cout << all(true, true, true, false) << std::endl; // 输出false
//	std::cout << sum(1, 2, 3, 4); // 输出 10
//	return 0;
//}

#include<iostream>
#include<vector>
#include<string>
// 3、⼆元左折叠
//template<typename... Strings>
//std::string concat_left(Strings... strs) {
//	return (std::string("%%") + ... + strs);
//	// 展开形式：((("%%" + str1) + str2)+ str3)
//} 
//// 、⼆元右折叠，初始值为空字符串
//template<typename... Strings>
//std::string concat_right(Strings... strs) {
//	return (strs + ... + std::string("%%"));
//	// 展开形式：str1 + (str2 + (str3 + "%%"))
//}
//
//
//int main() {
//	std::cout << concat_left("x", "y", "z") << "\n";
//	std::cout << concat_right("x", "y", "z") << "\n";
//}

//template<typename... Args>
//void print_with_separator(Args&&... args) {
//	auto print_elem = [](const auto& x) {
//		std::cout << x << " ";
//		};
//	(..., print_elem(args)); // ⼀元左折叠：
//	// ((print_elem(arg1),print_elem(arg2)), print_elem(arg3))
//	std::cout << std::endl;
//}
//template<typename T, typename... Args>
//void push_back_vec(std::vector<T>& v, Args&&... args)
//{
//	(v.push_back(std::forward<Args>(args)), ...);
//}
//
//int main() {
//
//	std::vector<int> v;
//	push_back_vec(v, 1, 2, 3, 4);
//	for (int i : v)
//		std::cout << i << ' ';
//	std::cout << '\n';
//	//print_with_separator(1, "hello", 3.14);
//
//	//print_with_separator();
//
//
//}
//#include <iostream>
//#include <vector>
//#include <tuple>
//#include <array>
//
//
// 
//int main() {
//	std::vector v2({ 10,1 });
//	std::array a = { 1, 2, 3 }; // 推导为array<int, 3>
//	std::pair p(1, 2.0); // 推导为pair<int, double>
//	std::tuple t(1, 2.0, "three"); // 推导为tuple<int, double, const char*>
//	std::cout << "v2 size: " << v2.size() << std::endl;
//	std::cout << "a size: " << a.size() << std::endl;
//	std::cout << "p first: " << p.first << ", second: " << p.second <<
//		std::endl;
//	return 0;
//}


/*⾮类型模板参数*/


//#include <iostream>
//#include <string>
//#include <string_view>
//#include <array>
//#include <typeinfo>
//template<auto Value>
//void printValue() {
//	//std::cout << "Value: " << Value << std::endl;
//	std::cout << "Type: " << typeid(Value).name() << std::endl; // 打印类型名（编译器相关）
//		std::cout << "---" << std::endl;
//}
//const char arr[] = "hello";
//
//struct Point {
//	int x;
//	int y;
//	// 编译器会为我们⽣成⼀个隐式的 constexpr 构造函数
//	// 析构函数也是隐式 constexpr 的
//};
//int main() {
//
//	// C++20开始⽀持字⾯量类类型作为⾮类型模板参数
//	printValue < Point{ 10, 20 } > ();
//	constexpr std::array arr{ 1, 2, 3, 4, 5 };
//	printValue<arr>();
//	printValue<3.14>(); // auto 被推导为 double C++20开始才⽀持
//
//	//printValue<42>(); // auto 被推导为 int
//	//printValue<'A'>(); // auto 被推导为 char
//	//printValue<true>(); // auto 被推导为 bool
//	//printValue<nullptr>(); // auto 被推导为 nullptr_t
//	//// printValue<"hello">(); // 错误：字符串字⾯量不能作为⾮类型模板参数
//	//printValue<arr>(); // auto 被推导为 const char*
//
//}

/*嵌套命名空间定义*/


//namespace A {
//	namespace B {
//		namespace C {
//			void foo() {
//				std::cout << "Old nested namespace style" << std::endl;
//			}
//		}
//	}
//} 
//// C++17的简洁嵌套命名空间
//namespace A::B::C {
//	void bar() {
//		std::cout << "New nested namespace style" << std::endl;
//	}
//}
//
//namespace ABC = A::B::C;
//int main() {
//
//	//A::B::C::bar();
//	ABC::bar();
//}

/*__has_include*/

//#if __has_include(<some_header.h>)
////有就直接包含
//#include <some_header.h>
//
//#else
//   //没有对应头文件需要进行操作：
//#pragma message("Warning: <some_header.h> not found, using fallback.")
//
//#endif
//
//#include <iostream>
//
//int main() {
//#if defined(_WIN32) || defined(_WIN64)
//    // Windows 系统（_WIN32 在 32 位和 64 位 Windows 下均被定义）
//    std::cout << "Hello from Windows!" << std::endl;
//#elif defined(__linux__)
//    // Linux 系统
//    std::cout << "Hello from Linux!" << std::endl;
//#elif defined(__APPLE__) && defined(__MACH__)
//    // macOS 系统（__APPLE__ 和 __MACH__ 同时定义）
//    std::cout << "Hello from macOS!" << std::endl;
//#else
//    // 其他未知平台
//    std::cout << "Hello from an unknown platform!" << std::endl;
//#endif
//
//    return 0;
//}
//
//int main() {
//
//
//}



/*属性*/


//#include <cstdlib>
//#include <iostream>
//#include <stdexcept>
//// 1. 终⽌程序的函数
//[[noreturn]] void fatal_error(const std::string& message) {
//	std::cerr << "Fatal error: " << message << std::endl;
//	//std::exit(EXIT_FAILURE);
//	// 不需要 return 语句
//	return;
//} 
//// 2. 总是抛出异常的函数
//[[noreturn]] void throw_runtime_error(const char* message) {
//	throw std::runtime_error(message);
//	// 不会执⾏到这⾥
//} 
//// 3. ⽆限循环的函数
//[[noreturn]] void event_loop() {
//	while (true) {
//		// 处理事件...
//	} 
//	// 不会执⾏到这⾥
//} 
//// 编译器优化⽰例
//int main() {
//		fatal_error("error exit");
//		
//	}


//#include <iostream>
//
//// 用 [[deprecated]] 标记一个旧函数，表示它已废弃，不推荐再使用
//// 可以加一段提示信息，比如："请改用新的函数 newFunction()"
//[[deprecated("此函数已废弃，请使用 newFunction() 替代")]]
//void oldFunction() {
//    std::cout << "这是一个旧的函数，不推荐再使用了！" << std::endl;
//}
//
//// 新的推荐函数
//void newFunction() {
//    std::cout << "这是新的推荐函数！" << std::endl;
//}
//
//int main() {
//    oldFunction();     // 调用被标记为 deprecated 的函数
//    newFunction();     // 调用新函数
//    return 0;
//}

//#include <iostream>
//[[nodiscard]] int calculate() {
//	return 42; // 这个返回值很重要，调用方不该忽略
//}
//int main() {
//	calculate(); // 编译器可能警告：返回值被忽略了
//	int x = calculate(); // 正常使用返回值，不会有警告
//	std::cout << x << std::endl;
//	return 0;
//}



//#include <iostream>
//void printMessage([[maybe_unused]] const char* msg) {
//
//	if (false) {
//		std::cout << msg << std::endl;
//	}
//}
//int main() {
//	int maybeUnusedVar = 100;
//
//	printMessage("Hello, [[maybe_unused]]!");
//	return 0;
//}

//#include <iostream>
//#include <string>
//void handle_input(const std::string& input) {
//	if (input == "valid") [[likely]] {
//		// 大概率走的逻辑：合法输入处理
//		std::cout << "处理合法输入: " << input << '\n';
//	}
//	else {
//		// 小概率走的逻辑：非法输入处理
//		std::cout << "处理非法输入: " << input << '\n';
//	}
//}
//int main() {
//	// 模拟多次输入，绝大多数是 "valid"
//	for (int i = 0; i < 100; ++i) {
//		handle_input(i % 100 != 99 ? "valid" : "invalid");
//	}
//	return 0;
//}


//struct Empty1{};
//struct Empty2 {};
//struct Foo {
//	int x; // 4 bytes
//	[[no_unique_address]] Empty1 e1; // 可能被优化掉
//	[[no_unique_address]] Empty2 e2; // 可能被优化掉
//};
//// 空基类优化 (EBO - Empty Base Optimization)
//struct Fxx : Empty1 {
//	int x;
//};
//struct Fyy : Empty1, Empty2 {
//	int y;
//};
//
//int main() {
//
//	std::cout << sizeof(Empty1) << std::endl;
//	std::cout << sizeof(Foo) << std::endl;
//	// EBO可以优化⼀个空基类，多个空基类就不⾏了
//	std::cout << sizeof(Fxx) << std::endl;
//	std::cout << sizeof(Fyy) << std::endl;
//}


/*新的求值顺序规则*/
//#include <iostream>
//#include<map>
//void process(int a, int b) {
//	std::cout << "a = " << a << ", b = " << b << std::endl;
//} 
//
//int main() {
//	int x = 0;
//	// C++17 前：未指定⾏为！
//	process(x++, x++); // 可能输出 (0,1) 或 (1,0)
//	int i = 0;
//	int j = 0;
//	// C++17 前：未定义⾏为！
//	// C++17 后：明确先求值右边 (i++)，再求值左边 (i)
//	i = i++; // 现在明确：i = 1
//	std::map<int, int> m = { {1, 10}, {2, 20} };
//	auto it = m.begin();
//	// C++17 前：未定义⾏为！it++ 和 it->second 的求值顺序不确定
//	// C++17 后：明确先求值 it->second，再求值 it++
//	int value = it++->second; // 安全：value = 10, it 指向第⼆个元素
//	std::cout << value << std::endl;
//	return 0;
//}

/*optional*/

//#include<optional>
//
//int main() {
//	// 1、定义optional 对象
//	std::optional<int> maybeInt; // 初始为空
//	std::optional<std::string> maybeString = "Hello"; // 初始有值
//	std::optional<double> empty = std::nullopt; // 显式设置为空
//	// 2、检查是否有值
//	if (maybeInt.has_value()) {
//		std::cout << "has_value1" << std::endl;
//	}
//	// 或者更简洁的写法
//	if (maybeString) {
//		std::cout << "has_value2" << *maybeString << std::endl;
//	}
//	// 3、访问值
//	// 安全访问 - ⽆值时抛出 std::bad_optional_access
//	try {
//		int value = maybeInt.value();
//	}
//	catch (const std::bad_optional_access& e) {
//		std::cout << e.what() << std::endl;
//	}
//	maybeInt = 1;
//	// 不安全但快速的访问 - ⽆值时⾏为未定义
//	int value1 = *maybeInt;
//	// 带默认值的访问
//	int value2 = maybeInt.value_or(2); // ⽆值时返回2
//	std::cout << value2 << std::endl;
//	// 4、修改值
//	maybeInt = 42; // 赋新值
//	maybeInt = std::nullopt; // 设为空
//	maybeInt.reset(); // 设为空
//
//}
#include<optional>
#include<string>
#include<iostream>
#include<map>

//int main(){
//	std::map<std::string, int> indexMap = { {"张庄",1}, {"王村",2}, {"李家村",3}, {"王家坪",3} };
//auto findIndex = [&indexMap](const std::string& str)->std::optional<int>
//{
//auto it = indexMap.find(str);
//if (it != indexMap.end())
//{
//   return it->second;
//} 
//else
//{
//   return std::nullopt;
//}
//};
//std::string x;
//std::cin >> x;
//std::optional<int> index = findIndex(x);
//if (index)
//{
//     std::cout << x << "对应的编号为:" << *index << std::endl;
//} 
//else
//{
//         std::cout << x << "是⾮法顶点" << std::endl;
//}
//
//}

//#include <optional>
//#include <string>
//#include <unordered_set>
//
//using namespace std::literals;
//
//int main()
//{
//    using OptStr = std::optional<std::string>;
//
//    // hash<optional> makes it possible to use unordered_set
//    std::unordered_set<OptStr> s =
//    {
//        "ABC"s, "abc"s, std::nullopt, "def"s
//    };
//
//    for (const auto& o : s)
//        std::cout << o.value_or("(null)") << '\t' << std::hash<OptStr>{}(o) << '\n';
//
// 
//}


/*variant*/
#include <string>
#include <iostream>
#include<variant>
using namespace std;
//
//
//
//int main() {
//
//	variant<int, string, double> var( "1");//每次只支持初始化一个值
//	var = 1.1;
//	var = 1;
//	var = "1.2";//覆盖操作
//
//	cout << var.index() << endl;//返回当前有类型的索引从0开始
//
//
//	//这里是变量只能存储一种各类型
//	//cout << get<string>(var) << endl;
//	//cout << get<1>(var) << endl;
//
//	//try {
//	//	std::cout << std::get<double>(var) << std::endl; // 抛出异常
//	//} 
//	//
//	//catch(const std::bad_variant_access & e) {
//	//	std::cout << "Error: " << e.what() << std::endl;
//	//}
//
//	struct VisitorOP {
//		void operator()(int i) const {
//			std::cout << "int: " << i << '\n';
//		} void operator()(double d) const {
//			std::cout << "double: " << d << '\n';
//		} void operator()(const std::string& s) const {
//			std::cout << "string: " << s << '\n';
//		}
//	};
//
//
//	VisitorOP vp;
//	visit([&vp](auto& x) {
//		vp(x);
//
//		}, var);
//
//	//if (auto pval = std::get_if<int>(&var)) {
//	//	std::cout << "int value: " << *pval << std::endl;
//	//} 
//	//else if (auto pval = std::get_if<double>(&var)) {
//	//	std::cout << "double value: " << *pval << std::endl;
//	//}
//	//else if (auto pval = std::get_if<std::string>(&var)) {
//	//	std::cout << "string value: " << *pval << std::endl;
//	//}
//
//
//	
//}

/*variant应用*/
#include <string>
#include <iostream>
#include<variant>
#include<list>
#include<vector>
#include<set>


//using namespace std;
//
//template<class... Ts>
//struct overloaded : Ts... { using Ts::operator()...;  };
//// explicit deduction guide (not needed as of C++20)
//
//template<class... Ts>
//overloaded(Ts...)->overloaded<Ts...>;
//
//template<class K, size_t Len = 8>
//class HashTable
//{
//	using Value = std::variant<std::list<K>, std::set<K>>;
//public:
//	HashTable()
//		:_tables(10)
//	{}
//
//	void Insert(const K& key)
//	{
//		// 扩容
//		size_t hashi = key % _tables.size();
//
//		auto listInsert = [this, &key, hashi](std::list<K>& lt)
//		{
//			// 小于8，则插入到链表
//			if (lt.size() < Len)
//			{
//				lt.push_back(key);
//			}
//			else
//			{
//				// 大于8，则转换插入到红黑树(set)
//				std::set<K> s(lt.begin(), lt.end());
//				s.insert(key);
//
//				_tables[hashi] = move(s);
//			}
//		};
//
//		auto setInsert = [&key](std::set<K>& s)
//		{
//			s.insert(key);
//		};
//
//		std::visit(overloaded(
//			listInsert,
//			setInsert
//		), _tables[hashi]);
//	}
//
//	bool Find(const K& key)
//	{
//		size_t hashi = key % _tables.size();
//
//		// 链表查找
//		auto listFind = [&key](std::list<K>& lt)
//		{
//			return std::find(lt.begin(), lt.end(), key) != lt.end();
//		};
//
//		// 红黑树查找
//		auto setFind = [&key](std::set<K>& s)
//		{
//			return s.count(key) != 0;
//		};
//
//		return std::visit(overloaded(
//			listFind,
//			setFind
//		), _tables[hashi]);
//	}
//
//private:
//	std::vector<Value> _tables;
//};

//int main()
//{
//	HashTable<int> ht;
//	for (size_t i = 0; i < 10; i++)
//	{
//	ht.Insert(i * 10 + 5);
//	} 
//	
//	std::cout << ht.Find(15) << std::endl;
//	std::cout << ht.Find(3) << std::endl;
//	return 0;
//}

/*any测试*/



#include <iostream>
#include <any>
#include <string>
#include <vector>
#include <assert.h>


//
//int main() {
//
//	//这里创建any对象不用关心什么类型也就是实例化：
//	//std::any a1 = 42; // 存放 int
//	//std::any a2 = 3.14; // 存放 double
//	//std::any a3 = std::string("Hello"); // 存放 std::string
//	//std::any a4;
//	//a4 = std::pair<std::string, std::string>("xxxx", "yyyy");
//	//// 使⽤ emplace 原地构造
//	//// 现在 a3 包含 "World"，之前的 "Hello" 被销毁(和对应的variant一样只能存一个)；
//	//// 这里没有发生拷贝构造，而是利用emplace特性直接传给any对象底层的对应类型构造函数完成构造
//	//	a3.emplace<std::string>("World"); 
//
//	//	
//	//	if (a3.has_value() ){
//
//	//		std::cout << std::any_cast<std::string>(a3) << std::endl;
//	//	}
//
//	//	const std::type_info& ti = a3.type();
//
//	//	std::cout << ti.name() << std::endl;
//
//	//	a1.reset();
//	//	a3.reset();
//
//		
//	//std::string str("hello world");
//	//std::vector<std::any> v = { 1.1, 2, str };
//	//for (const auto& item : v) {
//	//	if (item.type() == typeid(int)) {
//	//		std::cout << "整数配置: " << std::any_cast<int>(item) << '\n';
//	//	}
//	//	else if (item.type() == typeid(double)) {
//	//		std::cout << "浮点配置: " << std::any_cast<double>(item) << '\n';
//	//	}
//	//	else if (item.type() == typeid(std::string)) {
//	//		std::cout << "字符串配置: " << std::any_cast<const std::string&>(item) <<
//	//			'\n';
//	//	}
//	//	else
//	//	{
//	//		assert(false);
//	//	}
//	//}
//	
//	//std::any a1 = 42; // 存放 int
//	//std::any a2 = 3.14; // 存放 double
//	//std::any a3 = std::string("Hello"); // 存放 std::string
//	//// ⽅式⼀：转换为值的类型（如果类型不匹配，抛出 std::bad_any_cast）
//	//	try {
//	//	int int_value = std::any_cast<int>(a1); // 正确，a1 存放的是 int
//	//	std::cout << "Value: " << int_value << '\n';
//	//	double double_value = std::any_cast<double>(a1); // 错误！抛出异常
//	//} catch(const std::bad_any_cast & e) {
//	//	std::cout << "Cast failed: " << e.what() << '\n';
//	//}
//
//
//	//if (auto ptr = std::any_cast<int>(&a1)) { // 传递指针，返回指针
//	//	std::cout << "Value via pointer: " << *ptr << '\n';
//	//}
//	//else{
//	//	std::cout << "Not an int or is empty.\n";
//	//}
//	//if (auto ptr = std::any_cast<double>(&a1)) { // 传递指针，返回指针
//	//	std::cout << "Value via pointer: " << *ptr << '\n';
//	//}
//	//else {
//	//	std::cout << "Not an int or is empty.\n";}
//
//
//
//	std::any a1 = 42; // 存放 int
//	std::any a2 = 3.14; // 存放 double
//	std::any a3 = std::string("Hello"); // 存放 std::string
//	std::string str_ref1 = std::any_cast<std::string>(a3);
//	str_ref1[0]++;
//	std::cout << std::any_cast<std::string>(a3) << '\n';
//	std::string& str_ref2 = std::any_cast<std::string&>(a3);
//	str_ref2[0]++;
//	std::cout << std::any_cast<std::string&>(a3) << '\n';
//
//	//重点
//	std::string&& str_ref3 = std::any_cast<std::string&&>(move(a3));
//	str_ref3[0]++;
//	std::cout << std::any_cast<std::string&>(a3) << '\n';
//	std::string str_ref4 = std::any_cast<std::string&&>(move(a3));
//	str_ref4[0]++;
//	std::cout << std::any_cast<std::string&>(a3) << '\n';
//
//	
//
//	
//
//
//}

//template<class K, size_t Len = 8>
//class HashTable
//{
//public:
//	HashTable()
//		:_tables(10, std::list<K>())
//	{}
//
//	void Insert(const K& key)
//	{
//		// 扩容
//		size_t hashi = key % _tables.size();
//
//		auto listInsert = [this, &key, hashi](std::list<K>& lt)
//		{
//			// 小于8，则插入到链表
//			if (lt.size() < Len)
//			{
//				lt.push_back(key);
//			}
//			else
//			{
//				// 大于8，则转换插入到红黑树(set)
//				std::set<K> s(lt.begin(), lt.end());
//				s.insert(key);
//
//				_tables[hashi] = move(s);
//			}
//		};
//
//		auto setInsert = [&key](std::set<K>& s)
//		{
//			s.insert(key);
//		};
//
//		if (auto ptr = any_cast<std::list<K>>(&_tables[hashi]))
//		{
//			listInsert(*ptr);
//		}
//		else if (auto ptr = any_cast<std::set<K>>(&_tables[hashi]))
//		{
//			setInsert(*ptr);
//		}
//		else
//		{
//			assert(false);
//		}
//	}
//
//	bool Find(const K& key)
//	{
//		size_t hashi = key % _tables.size();
//		// 链表查找
//		auto listFind = [&key](std::list<K>& lt)
//		{
//			return std::find(lt.begin(), lt.end(), key) != lt.end();
//		};
//
//		// 红黑树查找
//		auto setFind = [&key](std::set<K>& s)
//		{
//			return s.count(key) != 0;
//		};
//
//
//		if (auto ptr = any_cast<std::list<K>>(&_tables[hashi]))
//		{
//			return listFind(*ptr);
//		}
//		else if (auto ptr = any_cast<std::set<K>>(&_tables[hashi]))
//		{
//			return setFind(*ptr);
//		}
//		else
//		{
//			assert(false);
//			return false;
//		}
//	}
//
//private:
//	std::vector<std::any> _tables;
//};
//
//int main()
//{
//	HashTable<int> ht;
//	for (size_t i = 0; i < 10; i++)
//	{
//		ht.Insert(i * 10 + 5);
//	}
//
//	std::cout << ht.Find(15) << std::endl;
//	std::cout << ht.Find(3) << std::endl;
//
//	return 0;
//}

#include <iostream>
#include <string>
#include <string_view>
//void print(std::string_view sv) {
//	std::cout << "String view: " << sv << "\n";
//	std::cout << "Length: " << sv.size() << "\n";
//	for (size_t i = 0; i < sv.size(); ++i)
//	{
//		std::cout << sv[i] << " ";
//	} 
//	std::cout << "\n";
//	for (auto  ch : sv)
//	{
//		std::cout << ch << " ";
//	}
//	std::cout << "\n";
//}
//int main() {
//	// 从C⻛格字符串构造
//	std::string_view sv1("Hello, world!\0");
//	print(sv1);
//	// 从std::string构造
//	std::string str = "C++17 string_view";
//	std::string_view sv2(str);
//	print(sv2);
//	// 从部分字符串构造
//	std::string_view sv3(str.c_str() + 6, 6);
//	print(sv3);
//	// 从字⾯量构造
//	using namespace std::literals;
//	std::string_view sv4 = "Literal"sv;
//	print(sv4);
//
//}


/*使用案例*/

#include <iostream>
#include <vector>
#include <string_view>
void process_string(std::string_view sv)
{
    // 处理字符串，⽆需关⼼原始类型
}



// 函数：接收 string_view 参数，避免 const string& 的隐式构造开销
//void printAndSplit(std::string_view str, char delimiter) {
//    std::cout << "原始字符串视图: " << str << "\n";
//
//    std::vector<std::string_view> tokens;  // 仅保存视图，不拷贝子字符串
//    size_t start = 0;
//    size_t end = str.find(delimiter);
//
//    while (end != std::string_view::npos) {
//        tokens.emplace_back(str.substr(start, end - start));  // substr 返回 string_view，零拷贝
//        start = end + 1;
//        end = str.find(delimiter, start);
//    }
//    // 添加最后一个 token
//    tokens.emplace_back(str.substr(start));
//
//    // 输出分割结果
//    std::cout << "分割结果（string_view，不拷贝）:\n";
//    for (const auto& token : tokens) {
//        std::cout << " - [" << token << "]\n";
//    }
//}
//
//int main() {
//    // 示例 1：传入字符串字面量（无需构造 std::string）
//    printAndSplit("apple,banana,orange", ',');
//
//    // 示例 2：传入 std::string（依然有效，但避免了一次拷贝）
//    std::string s = "one,two,three";
//    printAndSplit(s, ',');
//
//    return 0;
//}


/*注意事项*/
//
//std::string_view get_view() {
//    std::string temp = "Temporary string";
//    return temp; // 严重错误！temp将被销毁
//} 
//
//void error_example1() {
//    std::string_view sv = get_view(); // sv现在指向已释放的内存
//    std::cout << sv << std::endl; // 未定义⾏为
//}
//
//
//int main() {
//
//
//    //error_example1();
//
//
//    //char buffer[] = { 'T', 'e', 's', 't', '.', 't', 'x', 't','\0'}; // 不是空终⽌的
//    //std::string_view sv(buffer, 4); // 正确指定⻓度
//    //std::cout << sv << std::endl;
//    //std::string_view filename(buffer);
//    //FILE* fout = fopen(filename.data(), "w");
//    //
//    //if (fout != NULL)
//    //   {
//    //    fputs("fopen example", fout);
//    //    fclose(fout);
//    //} 
//    //
//    //else
//    //{
//    //perror("fopen fail");
//    //}
//
//
//    std::string str = "Hello";
//    std::string_view sv = str;
//    // 修改原始字符串会使string_view失效
//    str[0] = 'h'; // 合法，sv仍然有效
//    std::cout << sv << std::endl;
//    str.push_back('2');
//    std::cout << sv.size() << std::endl;
//
//    str = "New value 111111111111111111111111"; // 可能导致重新分配，使sv失效
//    std::cout << sv << std::endl;
//
//}



/*filesystem*/

//#include<filesystem>
//#include<iostream>
//using namespace std;
//namespace fs = std::filesystem;


//int main() {
//    // 范围for的⽅式遍历
//    // 非递归遍历
//    fs::path dir_path = fs::current_path();
//    //for (const auto& entry : fs::directory_iterator(dir_path)) {
//    //}
//    //// 递归遍历
//    //for (const auto& entry : fs::recursive_directory_iterator(dir_path)) {
//    //}
//    //// 带选项的遍历
//    //auto options = fs::directory_options::skip_permission_denied;
//    //for (const auto& entry : fs::recursive_directory_iterator(dir_path, options)) {
//    //    // 跳过⽆权限的⽬录
//    //}
//
//
//
//
//}

//#include <iostream>
//#include <filesystem>
//namespace fs = std::filesystem;
//
//int main() {
//    fs::path dir_path = "."; // 当前目录
//
//    std::cout << "非递归遍历目录内容:" << std::endl;
//
//    // 范围for的方式遍历 - 非递归遍历
//    for (const auto& entry : fs::directory_iterator(dir_path)) {
//        std::cout << entry.path().filename() << std::endl;
//    }
//
//    return 0;
//}


//#include <iostream>
//#include <filesystem>
//namespace fs = std::filesystem;
//
//int main() {
//    fs::path dir_path = "."; // 当前目录
//
//    std::cout << "递归遍历目录内容:" << std::endl;
//
//    // 递归遍历
//    for (const auto& entry : fs::recursive_directory_iterator(dir_path)) {
//
//         std::cout  << entry.path().filename() << std::endl;
//    }
//
//    return 0;
//}

//#include <iostream>
//#include <filesystem>
//namespace fs = std::filesystem;

//int main() {
//    fs::path dir_path = "."; // 当前目录
//
//    std::cout << "带选项的递归遍历（跳过无权限目录）:" << std::endl;
//
//    // 带选项的遍历 - 跳过无权限的目录
//    auto options = fs::directory_options::skip_permission_denied;
//    for (const auto& entry : fs::recursive_directory_iterator(dir_path, options)) {
//        try {
//            
//            std::cout   << entry.path().filename()
//                << " (类型: ";
//
//            if (entry.is_directory()) {
//                std::cout << "目录";
//            }
//            else if (entry.is_regular_file()) {
//                std::cout << "文件";
//            }
//            else {
//                std::cout << "其他";
//            }
//
//            std::cout << ")" << std::endl;
//        }
//        catch (const std::exception& e) {
//            std::cerr << "处理条目时出错: " << e.what() << std::endl;
//        }
//    }
//
//    return 0;
//}



//int main() {
//
//    // 异常的⽅式
//    //try {
//    //    fs::path p = "nonexistent.txt";
//    //    auto size = fs::file_size(p); // 可能抛出异常
//    //    std::cout << "⽂件⼤⼩: " << size << std::endl;
//    //} 
//    //catch(const fs::filesystem_error & ex) {
//    //    std::cout
//    //        << "what(): " << ex.what() << '\n'
//    //        << "path1(): " << ex.path1() << '\n'
//    //        << "path2(): " << ex.path2() << '\n';
//    //} 
//    // 错误码⽅式
//        std::error_code ec;
//    fs::path p = "nonexistent.txt";
//    auto size = fs::file_size(p, ec);
//    if (ec) {
//        std::cout << "错误代码: " << ec.value() << std::endl;
//        std::cout << "错误信息: " << ec.message() << std::endl;
//        std::cout << "错误类别: " << ec.category().name() << std::endl;
//    }
//    else{
//        std::cout << "⽂件⼤⼩: " << size << std::endl;
//    }
//
//}


/*execution policy*/


#include <algorithm>
#include <execution>
#include <vector>
#include <chrono>
#include <iostream>
void performance_comparison() {
    std::vector<int> data1(1000'0000);
    std::generate(data1.begin(), data1.end(), []() { return rand(); });
    std::vector<int> data2(data1);


    auto start = std::chrono::high_resolution_clock::now();
    std::sort(data1.begin(), data1.end()); // 顺序排序
    auto end = std::chrono::high_resolution_clock::now();
    std::cout << "Sequential sort: "
        << std::chrono::duration_cast<std::chrono::milliseconds>(end -
            start).count()
        << " ms\n";



    start = std::chrono::high_resolution_clock::now();
    std::sort(std::execution::unseq, data2.begin(), data2.end()); // 并⾏排序
    end = std::chrono::high_resolution_clock::now();
    std::cout << "Parallel sort: "
        << std::chrono::duration_cast<std::chrono::milliseconds>(end -
            start).count()
        << " ms\n";
    
} 
int main()
    {
        performance_comparison();
        return 0;
    }
   